package com.zhuiyun.project.api.products.product.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.zhuiyun.project.api.system.menu.entity.TreeSelect;
import com.zhuiyun.project.api.products.product.entity.Sort;
import com.zhuiyun.project.api.products.product.mapper.SortMapper;
import com.zhuiyun.project.api.products.product.service.SortService;
import com.zhuiyun.project.common.errorCode.EmErrorCode;
import com.zhuiyun.project.common.response.CommonResult;
import com.zhuiyun.project.utils.DateTimeUtils;
import com.zhuiyun.project.utils.DateUtils;
import com.zhuiyun.project.utils.StringUtils;
import com.zhuiyun.project.utils.pageUtil.MybatisPageHelper;
import com.zhuiyun.project.utils.pageUtil.PageRequest;
import com.zhuiyun.project.utils.pageUtil.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName SortServiceImpl
 * @Description TODO 商品分类实现类
 * @Author ypq
 * @Date 2023/10/25 19:12
 **/
@Service
public class SortServiceImpl extends ServiceImpl<SortMapper, Sort> implements SortService {

    @Autowired
    private SortMapper sortMapper;

    /**
    * @Author ypq
    * @Description 分类的全查方法
    * @Date 2023/10/27 9:16
    * @Return List<TreeSelect> 下拉树结构列表
    * @param sort
    */
    @Override
    public List<TreeSelect> listSorts(Sort sort) {
        //查询分类的所有数据
        List<Sort> sorts = sortMapper.listSorts(sort);
        return buildSortTreeSelect(sorts);
    }

    /**
    * @Author ypq
    * @Description 构建前端所需要下拉树结构
    * @Date 2023/10/27 10:47
    * @Return List<TreeSelect> 下拉树结构列表
    * @param sorts 分类列表
    */
    @Override
    public List<TreeSelect> buildSortTreeSelect(List<Sort> sorts)
    {
        List<Sort> sortTrees = buildSortTree(sorts);
        return sortTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    }

    /**
    * @Author ypq
    * @Description 构建前端所需要树结构
    * @Date 2023/10/27 10:57
    * @Return List<Sort>
    * @param sorts
    */
    @Override
    public List<Sort> buildSortTree(List<Sort> sorts) {
        List<Sort> returnList = new ArrayList<>();
        List<Long> tempList = sorts.stream().map(Sort::getSortId).collect(Collectors.toList());
        for (Sort sort : sorts) {
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(sort.getParentId())){
                recursionFn(sorts, sort);
                returnList.add(sort);
            }
        }
        if (returnList.isEmpty()) {
            returnList = sorts;
        }
        return returnList;
    }

    /**
    * @Author ypq
    * @Description 递归列表
    * @Date 2023/10/27 11:05
    * @Return void
    * @param sorts
    * @param sort
    */
    private void recursionFn(List<Sort> sorts, Sort sort) {
        // 得到子节点列表
        List<Sort> childList = getChildList(sorts,sort);
        sort.setChildren(childList);
        for (Sort tChild : childList)
        {
            if (hasChild(sorts, tChild))
            {
                recursionFn(sorts, tChild);
            }
        }

    }

    /**
    * @Author ypq
    * @Description 得到子节点列表
    * @Date 2023/10/27 11:11
    * @Return List<Sort>
    * @param sorts
    * @param t
    */
    private List<Sort> getChildList(List<Sort> sorts, Sort t)
    {
        List<Sort> tlist = new ArrayList<Sort>();
        Iterator<Sort> it = sorts.iterator();
        while (it.hasNext())
        {
            Sort n = (Sort) it.next();
            if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getSortId().longValue())
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
    * @Author ypq
    * @Description 判断是否有子节点
    * @Date 2023/10/27 11:10
    * @Return boolean
    * @param list 分类列表集合
    * @param t 每个分类
    */
    private boolean hasChild(List<Sort> list, Sort t)
    {
        return getChildList(list, t).size() > 0;
    }

    /**
     * @Author ypq
     * @Description 新增分类
     * @Date 2023/10/27 16:35
     * @Return CommonResult
     * @param sort
     */
    @Override
    public CommonResult addSort(Sort sort) {
        if(sort.getParentId() == null){
            sort.setParentId(0L);
            sort.setSortType(1);
        }
        int i = sortMapper.addSort(sort);
        // 判断是否操作成功
        if(i>0){
            return CommonResult.ok(EmErrorCode.SAVE_OK);
        }else{
            return CommonResult.ok(EmErrorCode.SAVE_ERROR);
        }
    }

    /**
     * @Author ypq
     * @Description 根据二级分类id查询对应三级分类
     * @Date 2023/11/14 10:27
     * @Return List<List<Sort>>
     * @param sortId
     */
    @Override
    public  List<List<Sort>> listSortBySortIds(Long sortId) {
        //查询对应分类子级
        List<Sort> sortList = sortMapper.listSortByParentIds(sortId);
        //判断sortList是否为空
        if (sortList == null || sortList.isEmpty() || sortList.size() < 1) {
            return Collections.emptyList();
        }
        //如果sortList不为空，将它切分成多个小集合
        List<List<Sort>> lists = Lists.partition(sortList, 6);
        return lists;
    }

    /**
     * @Author ypq
     * @Description 根据一级分类id查询对应二级分类
     * @Date 2023/11/14 18:53
     * @Return List<Sort>
     * @param parentId
     */
    @Override
    public List<Sort> listSortByParentIds(Long parentId) {
         //查询对应分类子级
        return sortMapper.listSortByParentIds(parentId);
    }

    /**
    * @Author ypq
    * @Description 查询审核通过的一级分类列表
    * @Date 2023/11/15 19:49
    * @Return List<Sort>
    * @param sort
    */
    @Override
    public List<Sort> listFirstSorts(Sort sort) {
        List<Sort> list = sortMapper.listSortPrimarys(sort);
        //过滤掉 待审核和驳回的分类，只保留审核通过的
        List<Sort> sortList = list.stream().filter(s -> ("0").equals(s.getApproval())).collect(Collectors.toList());
        for (Sort sorts : sortList) {
            sorts.setSortLevel(sorts.getSortName());
        }
        return sortList;
    }

    /**
     * @Author ypq
     * @Description 查询审核通过的二级分类列表
     * @Date 2023/11/15 19:18
     * @Return List<Sort>
     * @param sort
     */
    @Override
    public List<Sort> listSecondSorts(Sort sort) {
        List<Sort> list = sortMapper.listSortSecondarys(sort);
        //过滤掉 待审核和驳回的分类，只保留审核通过的
        List<Sort> sortList = list.stream().filter(s ->("0").equals(s.getApproval())).collect(Collectors.toList());
        for (Sort sorts : sortList) {
            //根据二级分类的父id查询对应的一级分类详情
            Sort parentSort = sortMapper.selectById(sorts.getParentId());
            //将分类层级拼成一个字符串
            String level = parentSort.getSortName() + " / " +sorts.getSortName();
            sorts.setSortLevel(level);
        }
        return sortList;
    }

    /**
     * @Author hyp
     * @Description 查询一级分类所有数据
     * @Date 2023/11/15 19:29
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param pageRequest
     * @param sort
     */
    @Override
    public PageResult listSortPrimarys(PageRequest pageRequest, Sort sort) {
        MybatisPageHelper.startPage(pageRequest);
        List<Sort> list = sortMapper.listSortPrimarys(sort);
        PageResult pageResult = MybatisPageHelper.getPageResult(list);
        return pageResult;
    }

    /**
     * @Author hyp
     * @Description 查询二级分类所有数据
     * @Date 2023/11/15 19:29
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param pageRequest
     * @param sort
     */
    @Override
    public PageResult listSortSecondarys(PageRequest pageRequest,Sort sort) {
        MybatisPageHelper.startPage(pageRequest);
        List<Sort> list = sortMapper.listSortSecondarys(sort);
        List<Sort> list1 = sortMapper.listSorts(new Sort());
        for (Sort sort2 : list) {
            for (Sort sort1 : list1) {
                if (sort2.getParentId() == sort1.getSortId()){
                    sort2.setParentName(sort1.getSortName());
                }
            }
        }

        PageResult pageResult = MybatisPageHelper.getPageResult(list);
        return pageResult;
    }


    /**
     * @Author hyp
     * @Description 查询三级分类所有数据
     * @Date 2023/11/15 19:29
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param pageRequest
     * @param sort
     */
    @Override
    public PageResult listSortThreeLevels(PageRequest pageRequest,Sort sort) {
        MybatisPageHelper.startPage(pageRequest);
        List<Sort> list = sortMapper.listSortThreeLevels(sort);
        List<Sort> list1 = sortMapper.listSorts(new Sort());
        for (Sort sort2 : list) {
            for (Sort sort1 : list1) {
                if (sort2.getParentId() == sort1.getSortId()){
                    sort2.setParentName(sort1.getSortName());
                }
            }
        }
        PageResult pageResult = MybatisPageHelper.getPageResult(list);
        return pageResult;
    }

    /**
     * @Author hyp
     * @Description 根据分类id查询
     * @Date 2023/11/15 19:33
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param sortId
     */
    @Override
    public Sort getSortById(Long sortId) {
        return sortMapper.getSortById(sortId);
    }

    /**
     * @Author hyp
     * @Description 根据分类id重置审批
     * @Date 2023/11/15 19:34
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param sortId
     */
    @Override
    public CommonResult resetApproval(Long sortId) {
        Sort sort = new Sort();
        Date createTime = DateUtils.getNowDate();
        sort.setSortId(sortId);
        sort.setCreateTime(createTime);
        sort.setUpdateTime(null);
        int i = sortMapper.resetApproval(sort);
        if(i>0){
            return CommonResult.ok(EmErrorCode.UPDATE_OK);
        }else{
            return CommonResult.ok(EmErrorCode.UPDATE_ERROR);
        }
    }
    /**
     * @Author hyp
     * @Description 查询所有分类
     * @Date 2023/11/22 20:41
     * @Return
     */
    @Override
    public List<Sort> listSortAll() {
        List<Sort> list = sortMapper.listSortAll();
        int i = 1;
        for (Sort sort : list) {

            sort.setSortName(i + "级分类");
            i++;
        }
        return list;
    }

    /**
     * @Author hyp
     * @Description 根据分类id通过审批
     * @Date 2023/11/15 19:31
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param sortId
     */
    @Override
    public CommonResult editApproval(Long sortId) {
        Sort sort = new Sort();
        sort.setSortId(sortId);
        Date updateTime = DateUtils.getNowDate();
        sort.setUpdateTime(updateTime);
        int i = sortMapper.editApproval(sort);
        if(i>0){
            return CommonResult.ok(EmErrorCode.UPDATE_OK);
        }else{
            return CommonResult.ok(EmErrorCode.UPDATE_ERROR);
        }
    }

    /**
     * @Author hyp
     * @Description 根据分类id驳回审批
     * @Date 2023/11/15 19:32
     * @Return com.zhuiyun.project.common.response.CommonResult
     * @param sortId
     */
    @Override
    public CommonResult editReject(Long sortId) {
        Sort sort = new Sort();
        sort.setSortId(sortId);
        Date updateTime = DateUtils.getNowDate();
        sort.setUpdateTime(updateTime);
        int i = sortMapper.editReject(sort);
        if(i>0){
            return CommonResult.ok(EmErrorCode.UPDATE_OK);
        }else{
            return CommonResult.ok(EmErrorCode.UPDATE_ERROR);
        }
    }
}
